home *** CD-ROM | disk | FTP | other *** search
/ Champak 103 / Vol 103.iso / games / screamin.swf / scripts / DefineSprite_81 / frame_2 / PlaceObject2_80_1 / CLIPACTIONRECORD onClipEvent(enterFrame).as next >
Text File  |  2010-03-13  |  51KB  |  761 lines
  1. onClipEvent(enterFrame){
  2.    var ┬º\x01┬º = 262;
  3.    loop0:
  4.    while(true)
  5.    {
  6.       if(eval("\x01") != 262)
  7.       {
  8.          if(eval("\x01") != 487)
  9.          {
  10.             if(eval("\x01") != 106)
  11.             {
  12.                if(eval("\x01") != 639)
  13.                {
  14.                   if(eval("\x01") == 641)
  15.                   {
  16.                      set("\x01",eval("\x01") - 2);
  17.                      break;
  18.                   }
  19.                   if(eval("\x01") != 98)
  20.                   {
  21.                      if(eval("\x01") == 971)
  22.                      {
  23.                         set("\x01",eval("\x01") - 48);
  24.                         ramp++;
  25.                         _root.mainRoad.bigCar2._x += spinOut;
  26.                         _root.mainRoad.bigCar2._y -= 5 + (5 - ramp);
  27.                         break;
  28.                      }
  29.                      if(eval("\x01") == 213)
  30.                      {
  31.                         set("\x01",eval("\x01") + 530);
  32.                         continue;
  33.                      }
  34.                      if(eval("\x01") == 743)
  35.                      {
  36.                         set("\x01",eval("\x01") + 228);
  37.                         continue;
  38.                      }
  39.                      if(eval("\x01") == 565)
  40.                      {
  41.                         set("\x01",eval("\x01") + 178);
  42.                         continue;
  43.                      }
  44.                      if(eval("\x01") != 143)
  45.                      {
  46.                         if(eval("\x01") == 24)
  47.                         {
  48.                            set("\x01",eval("\x01") + 541);
  49.                            loop1:
  50.                            while(true)
  51.                            {
  52.                               set(┬º┬ºpop(),┬º┬ºpop() + 324);
  53.                               while(true)
  54.                               {
  55.                                  if(eval("\x01") == 545)
  56.                                  {
  57.                                     set("\x01",eval("\x01") - 139);
  58.                                     ┬º┬ºpush(true);
  59.                                  }
  60.                                  else if(eval("\x01") == 187)
  61.                                  {
  62.                                     set("\x01",eval("\x01") + 97);
  63.                                  }
  64.                                  else if(eval("\x01") == 32)
  65.                                  {
  66.                                     set("\x01",eval("\x01") + 676);
  67.                                     if(┬º┬ºpop())
  68.                                     {
  69.                                        set("\x01",eval("\x01") - 185);
  70.                                     }
  71.                                  }
  72.                                  else
  73.                                  {
  74.                                     if(eval("\x01") == 399)
  75.                                     {
  76.                                        set("\x01",eval("\x01") + 497);
  77.                                        break loop0;
  78.                                     }
  79.                                     if(eval("\x01") == 831)
  80.                                     {
  81.                                        set("\x01",eval("\x01") - 642);
  82.                                        ┬º┬ºpush(true);
  83.                                     }
  84.                                     else
  85.                                     {
  86.                                        if(eval("\x01") == 634)
  87.                                        {
  88.                                           set("\x01",eval("\x01") - 447);
  89.                                           break loop0;
  90.                                        }
  91.                                        if(eval("\x01") == 357)
  92.                                        {
  93.                                           set("\x01",eval("\x01") + 42);
  94.                                           if(┬º┬ºpop())
  95.                                           {
  96.                                              set("\x01",eval("\x01") + 497);
  97.                                           }
  98.                                        }
  99.                                        else if(eval("\x01") == 896)
  100.                                        {
  101.                                           set("\x01",eval("\x01") - 115);
  102.                                        }
  103.                                        else if(eval("\x01") == 674)
  104.                                        {
  105.                                           set("\x01",eval("\x01") - 425);
  106.                                        }
  107.                                        else if(eval("\x01") == 189)
  108.                                        {
  109.                                           set("\x01",eval("\x01") + 445);
  110.                                           if(┬º┬ºpop())
  111.                                           {
  112.                                              set("\x01",eval("\x01") - 447);
  113.                                           }
  114.                                        }
  115.                                        else if(eval("\x01") == 431)
  116.                                        {
  117.                                           set("\x01",eval("\x01") - 182);
  118.                                        }
  119.                                        else if(eval("\x01") == 40)
  120.                                        {
  121.                                           set("\x01",eval("\x01") + 244);
  122.                                        }
  123.                                        else
  124.                                        {
  125.                                           if(eval("\x01") == 866)
  126.                                           {
  127.                                              set("\x01",eval("\x01") - 435);
  128.                                              loop3:
  129.                                              while(true)
  130.                                              {
  131.                                                 set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  132.                                                 while(true)
  133.                                                 {
  134.                                                    if(eval("\x01") == 374)
  135.                                                    {
  136.                                                       set("\x01",eval("\x01") + 553);
  137.                                                       ┬º┬ºpush(true);
  138.                                                       continue;
  139.                                                    }
  140.                                                    if(eval("\x01") == 332)
  141.                                                    {
  142.                                                       set("\x01",eval("\x01") - 24);
  143.                                                       loop5:
  144.                                                       while(true)
  145.                                                       {
  146.                                                          while(true)
  147.                                                          {
  148.                                                             if(eval("\x01") == 945)
  149.                                                             {
  150.                                                                set("\x01",eval("\x01") - 721);
  151.                                                                ┬º┬ºpush(true);
  152.                                                             }
  153.                                                             else if(eval("\x01") == 470)
  154.                                                             {
  155.                                                                set("\x01",eval("\x01") + 34);
  156.                                                             }
  157.                                                             else if(eval("\x01") == 743)
  158.                                                             {
  159.                                                                set("\x01",eval("\x01") - 270);
  160.                                                                ┬º┬ºpush(true);
  161.                                                             }
  162.                                                             else
  163.                                                             {
  164.                                                                if(eval("\x01") == 428)
  165.                                                                {
  166.                                                                   set("\x01",eval("\x01") - 337);
  167.                                                                   ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  168.                                                                   break loop0;
  169.                                                                }
  170.                                                                if(eval("\x01") == 44)
  171.                                                                {
  172.                                                                   set("\x01",eval("\x01") + 460);
  173.                                                                }
  174.                                                                else
  175.                                                                {
  176.                                                                   if(eval("\x01") == 90)
  177.                                                                   {
  178.                                                                      set("\x01",eval("\x01") + 527);
  179.                                                                      break loop0;
  180.                                                                   }
  181.                                                                   if(eval("\x01") == 40)
  182.                                                                   {
  183.                                                                      set("\x01",eval("\x01") + 11);
  184.                                                                   }
  185.                                                                   else if(eval("\x01") == 5)
  186.                                                                   {
  187.                                                                      set("\x01",eval("\x01") + 458);
  188.                                                                      if(┬º┬ºpop())
  189.                                                                      {
  190.                                                                         set("\x01",eval("\x01") - 262);
  191.                                                                      }
  192.                                                                   }
  193.                                                                   else if(eval("\x01") == 924)
  194.                                                                   {
  195.                                                                      set("\x01",eval("\x01") - 20);
  196.                                                                      ┬º┬ºpush(true);
  197.                                                                   }
  198.                                                                   else
  199.                                                                   {
  200.                                                                      if(eval("\x01") == 528)
  201.                                                                      {
  202.                                                                         set("\x01",eval("\x01") - 111);
  203.                                                                         break loop0;
  204.                                                                      }
  205.                                                                      if(eval("\x01") == 860)
  206.                                                                      {
  207.                                                                         set("\x01",eval("\x01") + 64);
  208.                                                                      }
  209.                                                                      else if(eval("\x01") == 91)
  210.                                                                      {
  211.                                                                         set("\x01",eval("\x01") - 80);
  212.                                                                      }
  213.                                                                      else if(eval("\x01") == 51)
  214.                                                                      {
  215.                                                                         set("\x01",eval("\x01") + 711);
  216.                                                                         ┬º┬ºpush(true);
  217.                                                                      }
  218.                                                                      else if(eval("\x01") == 504)
  219.                                                                      {
  220.                                                                         set("\x01",eval("\x01") - 499);
  221.                                                                         ┬º┬ºpush(true);
  222.                                                                      }
  223.                                                                      else if(eval("\x01") == 464)
  224.                                                                      {
  225.                                                                         set("\x01",eval("\x01") - 453);
  226.                                                                      }
  227.                                                                      else if(eval("\x01") == 24)
  228.                                                                      {
  229.                                                                         set("\x01",eval("\x01") + 719);
  230.                                                                      }
  231.                                                                      else if(eval("\x01") == 224)
  232.                                                                      {
  233.                                                                         set("\x01",eval("\x01") + 304);
  234.                                                                         if(┬º┬ºpop())
  235.                                                                         {
  236.                                                                            set("\x01",eval("\x01") - 111);
  237.                                                                         }
  238.                                                                      }
  239.                                                                      else if(eval("\x01") == 201)
  240.                                                                      {
  241.                                                                         set("\x01",eval("\x01") + 723);
  242.                                                                      }
  243.                                                                      else if(eval("\x01") == 865)
  244.                                                                      {
  245.                                                                         set("\x01",eval("\x01") - 433);
  246.                                                                      }
  247.                                                                      else if(eval("\x01") == 686)
  248.                                                                      {
  249.                                                                         set("\x01",eval("\x01") + 78);
  250.                                                                      }
  251.                                                                      else if(eval("\x01") == 904)
  252.                                                                      {
  253.                                                                         set("\x01",eval("\x01") - 476);
  254.                                                                         if(┬º┬ºpop())
  255.                                                                         {
  256.                                                                            set("\x01",eval("\x01") - 337);
  257.                                                                         }
  258.                                                                      }
  259.                                                                      else if(eval("\x01") == 809)
  260.                                                                      {
  261.                                                                         set("\x01",eval("\x01") - 627);
  262.                                                                         ┬º┬ºpush(true);
  263.                                                                      }
  264.                                                                      else if(eval("\x01") == 473)
  265.                                                                      {
  266.                                                                         set("\x01",eval("\x01") - 383);
  267.                                                                         if(┬º┬ºpop())
  268.                                                                         {
  269.                                                                            set("\x01",eval("\x01") + 527);
  270.                                                                         }
  271.                                                                      }
  272.                                                                      else
  273.                                                                      {
  274.                                                                         if(eval("\x01") == 551)
  275.                                                                         {
  276.                                                                            set("\x01",eval("\x01") - 507);
  277.                                                                            break loop0;
  278.                                                                         }
  279.                                                                         if(eval("\x01") == 463)
  280.                                                                         {
  281.                                                                            set("\x01",eval("\x01") - 262);
  282.                                                                            ┬º┬ºpush({});
  283.                                                                            break loop0;
  284.                                                                         }
  285.                                                                         if(eval("\x01") == 876)
  286.                                                                         {
  287.                                                                            set("\x01",eval("\x01") - 325);
  288.                                                                            if(┬º┬ºpop())
  289.                                                                            {
  290.                                                                               set("\x01",eval("\x01") - 507);
  291.                                                                            }
  292.                                                                         }
  293.                                                                         else if(eval("\x01") == 417)
  294.                                                                         {
  295.                                                                            set("\x01",eval("\x01") - 366);
  296.                                                                         }
  297.                                                                         else if(eval("\x01") == 432)
  298.                                                                         {
  299.                                                                            set("\x01",eval("\x01") + 444);
  300.                                                                            ┬º┬ºpush(true);
  301.                                                                         }
  302.                                                                         else
  303.                                                                         {
  304.                                                                            if(eval("\x01") == 570)
  305.                                                                            {
  306.                                                                               set("\x01",eval("\x01") - 276);
  307.                                                                               break loop0;
  308.                                                                            }
  309.                                                                            if(eval("\x01") == 617)
  310.                                                                            {
  311.                                                                               set("\x01",eval("\x01") + 192);
  312.                                                                            }
  313.                                                                            else
  314.                                                                            {
  315.                                                                               if(eval("\x01") == 11)
  316.                                                                               {
  317.                                                                                  set("\x01",eval("\x01") + 429);
  318.                                                                                  _root.helpDisplay._visible = false;
  319.                                                                                  break loop0;
  320.                                                                               }
  321.                                                                               if(eval("\x01") == 901)
  322.                                                                               {
  323.                                                                                  set("\x01",eval("\x01") - 469);
  324.                                                                               }
  325.                                                                               else
  326.                                                                               {
  327.                                                                                  if(eval("\x01") == 440)
  328.                                                                                  {
  329.                                                                                     set("\x01",eval("\x01") - 440);
  330.                                                                                     break loop0;
  331.                                                                                  }
  332.                                                                                  if(eval("\x01") == 477)
  333.                                                                                  {
  334.                                                                                     set("\x01",eval("\x01") + 287);
  335.                                                                                  }
  336.                                                                                  else
  337.                                                                                  {
  338.                                                                                     if(eval("\x01") == 817)
  339.                                                                                     {
  340.                                                                                        break loop5;
  341.                                                                                     }
  342.                                                                                     if(eval("\x01") == 764)
  343.                                                                                     {
  344.                                                                                        set("\x01",eval("\x01") + 16);
  345.                                                                                        ┬º┬ºpush(true);
  346.                                                                                     }
  347.                                                                                     else if(eval("\x01") == 762)
  348.                                                                                     {
  349.                                                                                        set("\x01",eval("\x01") + 97);
  350.                                                                                        if(┬º┬ºpop())
  351.                                                                                        {
  352.                                                                                           set("\x01",eval("\x01") - 382);
  353.                                                                                        }
  354.                                                                                     }
  355.                                                                                     else
  356.                                                                                     {
  357.                                                                                        if(eval("\x01") == 859)
  358.                                                                                        {
  359.                                                                                           set("\x01",eval("\x01") - 382);
  360.                                                                                           break loop0;
  361.                                                                                        }
  362.                                                                                        if(eval("\x01") == 780)
  363.                                                                                        {
  364.                                                                                           break;
  365.                                                                                        }
  366.                                                                                        if(eval("\x01") == 294)
  367.                                                                                        {
  368.                                                                                           set("\x01",eval("\x01") + 449);
  369.                                                                                        }
  370.                                                                                        else if(eval("\x01") == 182)
  371.                                                                                        {
  372.                                                                                           set("\x01",eval("\x01") + 635);
  373.                                                                                           if(┬º┬ºpop())
  374.                                                                                           {
  375.                                                                                              set("\x01",eval("\x01") + 48);
  376.                                                                                           }
  377.                                                                                        }
  378.                                                                                        else
  379.                                                                                        {
  380.                                                                                           if(eval("\x01") != 823)
  381.                                                                                           {
  382.                                                                                              break loop0;
  383.                                                                                           }
  384.                                                                                           set("\x01",eval("\x01") - 14);
  385.                                                                                        }
  386.                                                                                     }
  387.                                                                                  }
  388.                                                                               }
  389.                                                                            }
  390.                                                                         }
  391.                                                                      }
  392.                                                                   }
  393.                                                                }
  394.                                                             }
  395.                                                          }
  396.                                                          set("\x01",eval("\x01") - 210);
  397.                                                          if(┬º┬ºpop())
  398.                                                          {
  399.                                                             set("\x01",eval("\x01") - 276);
  400.                                                          }
  401.                                                       }
  402.                                                       set("\x01",eval("\x01") + 48);
  403.                                                       break loop0;
  404.                                                    }
  405.                                                    if(eval("\x01") == 792)
  406.                                                    {
  407.                                                       set("\x01",eval("\x01") - 460);
  408.                                                       if(┬º┬ºpop())
  409.                                                       {
  410.                                                          set("\x01",eval("\x01") - 24);
  411.                                                       }
  412.                                                       continue;
  413.                                                    }
  414.                                                    if(eval("\x01") == 535)
  415.                                                    {
  416.                                                       set("\x01",eval("\x01") + 89);
  417.                                                       if(┬º┬ºpop())
  418.                                                       {
  419.                                                          set("\x01",eval("\x01") + 65);
  420.                                                       }
  421.                                                       continue;
  422.                                                    }
  423.                                                    if(eval("\x01") == 169)
  424.                                                    {
  425.                                                       set("\x01",eval("\x01") + 710);
  426.                                                       continue;
  427.                                                    }
  428.                                                    if(eval("\x01") == 456)
  429.                                                    {
  430.                                                       set("\x01",eval("\x01") + 172);
  431.                                                       continue;
  432.                                                    }
  433.                                                    if(eval("\x01") == 628)
  434.                                                    {
  435.                                                       set("\x01",eval("\x01") - 93);
  436.                                                       ┬º┬ºpush(true);
  437.                                                       continue;
  438.                                                    }
  439.                                                    if(eval("\x01") == 624)
  440.                                                    {
  441.                                                       break loop3;
  442.                                                    }
  443.                                                    if(eval("\x01") == 930)
  444.                                                    {
  445.                                                       set("\x01",eval("\x01") - 654);
  446.                                                       ┬º┬ºpush(true);
  447.                                                       continue;
  448.                                                    }
  449.                                                    if(eval("\x01") == 999)
  450.                                                    {
  451.                                                       break;
  452.                                                    }
  453.                                                    if(eval("\x01") == 452)
  454.                                                    {
  455.                                                       set("\x01",eval("\x01") + 547);
  456.                                                       try
  457.                                                       {
  458.                                                       }
  459.                                                       finally
  460.                                                       {
  461.                                                       }
  462.                                                       break loop0;
  463.                                                    }
  464.                                                    if(eval("\x01") == 445)
  465.                                                    {
  466.                                                       set("\x01",eval("\x01") + 485);
  467.                                                       continue;
  468.                                                    }
  469.                                                    if(eval("\x01") == 879)
  470.                                                    {
  471.                                                       set("\x01",eval("\x01") + 101);
  472.                                                       _root.bigCar3Speed = 0;
  473.                                                       gotoAndStop(1);
  474.                                                       break loop0;
  475.                                                    }
  476.                                                    if(eval("\x01") == 308)
  477.                                                    {
  478.                                                       set("\x01",eval("\x01") + 622);
  479.                                                       continue;
  480.                                                    }
  481.                                                    if(eval("\x01") == 537)
  482.                                                    {
  483.                                                       set("\x01",eval("\x01") - 246);
  484.                                                       continue;
  485.                                                    }
  486.                                                    if(eval("\x01") == 123)
  487.                                                    {
  488.                                                       set("\x01",eval("\x01") + 756);
  489.                                                       continue;
  490.                                                    }
  491.                                                    if(eval("\x01") == 689)
  492.                                                    {
  493.                                                       set("\x01",eval("\x01") + 181);
  494.                                                       continue;
  495.                                                    }
  496.                                                    if(eval("\x01") == 291)
  497.                                                    {
  498.                                                       set("\x01",eval("\x01") + 501);
  499.                                                       ┬º┬ºpush(true);
  500.                                                       continue;
  501.                                                    }
  502.                                                    if(eval("\x01") == 538)
  503.                                                    {
  504.                                                       set("\x01",eval("\x01") + 332);
  505.                                                       continue;
  506.                                                    }
  507.                                                    if(eval("\x01") == 276)
  508.                                                    {
  509.                                                       set("\x01",eval("\x01") + 176);
  510.                                                       if(┬º┬ºpop())
  511.                                                       {
  512.                                                          set("\x01",eval("\x01") + 547);
  513.                                                       }
  514.                                                       continue;
  515.                                                    }
  516.                                                    if(eval("\x01") == 870)
  517.                                                    {
  518.                                                       set("\x01",eval("\x01") - 395);
  519.                                                       ┬º┬ºpush(true);
  520.                                                       continue;
  521.                                                    }
  522.                                                    if(eval("\x01") == 726)
  523.                                                    {
  524.                                                       set("\x01",eval("\x01") - 435);
  525.                                                       continue;
  526.                                                    }
  527.                                                    if(eval("\x01") == 288)
  528.                                                    {
  529.                                                       set("\x01",eval("\x01") + 438);
  530.                                                       ┬º┬ºpush(ord(┬º┬ºpop()));
  531.                                                       break loop0;
  532.                                                    }
  533.                                                    if(eval("\x01") == 927)
  534.                                                    {
  535.                                                       set("\x01",eval("\x01") - 639);
  536.                                                       if(┬º┬ºpop())
  537.                                                       {
  538.                                                          set("\x01",eval("\x01") + 438);
  539.                                                       }
  540.                                                       continue;
  541.                                                    }
  542.                                                    if(eval("\x01") != 56)
  543.                                                    {
  544.                                                       if(eval("\x01") != 475)
  545.                                                       {
  546.                                                          if(eval("\x01") == 980)
  547.                                                          {
  548.                                                             set("\x01",eval("\x01") - 980);
  549.                                                             break loop0;
  550.                                                          }
  551.                                                          break loop0;
  552.                                                       }
  553.                                                       set("\x01",eval("\x01") - 419);
  554.                                                       if(┬º┬ºpop())
  555.                                                       {
  556.                                                          set("\x01",eval("\x01") + 113);
  557.                                                       }
  558.                                                       continue;
  559.                                                    }
  560.                                                    set("\x01",eval("\x01") + 113);
  561.                                                    ┬º┬ºpop() extends [];
  562.                                                    ┬º┬ºpush(┬º┬ºpop() gt ┬º┬ºpop() + new ┬º\┬º\┬ºpop()┬º());
  563.                                                 }
  564.                                              }
  565.                                              set("\x01",eval("\x01") + 65);
  566.                                              break loop0;
  567.                                           }
  568.                                           if(eval("\x01") == 842)
  569.                                           {
  570.                                              set("\x01",eval("\x01") - 485);
  571.                                              ┬º┬ºpush(true);
  572.                                              continue;
  573.                                           }
  574.                                           if(eval("\x01") == 523)
  575.                                           {
  576.                                              set("\x01",eval("\x01") + 308);
  577.                                              continue;
  578.                                           }
  579.                                           if(eval("\x01") == 312)
  580.                                           {
  581.                                              set("\x01",eval("\x01") + 530);
  582.                                              continue;
  583.                                           }
  584.                                           if(eval("\x01") == 284)
  585.                                           {
  586.                                              set("\x01",eval("\x01") + 21);
  587.                                              ┬º┬ºpush(true);
  588.                                              continue;
  589.                                           }
  590.                                           if(eval("\x01") == 874)
  591.                                           {
  592.                                              set("\x01",eval("\x01") - 32);
  593.                                              continue;
  594.                                           }
  595.                                           if(eval("\x01") == 135)
  596.                                           {
  597.                                              break;
  598.                                           }
  599.                                           if(eval("\x01") == 781)
  600.                                           {
  601.                                              set("\x01",eval("\x01") - 749);
  602.                                              ┬º┬ºpush(true);
  603.                                              continue;
  604.                                           }
  605.                                           if(eval("\x01") == 249)
  606.                                           {
  607.                                              set("\x01",eval("\x01") + 171);
  608.                                              continue;
  609.                                           }
  610.                                           if(eval("\x01") == 305)
  611.                                           {
  612.                                              set("\x01",eval("\x01") - 93);
  613.                                              if(┬º┬ºpop())
  614.                                              {
  615.                                                 set("\x01",eval("\x01") + 718);
  616.                                              }
  617.                                              continue;
  618.                                           }
  619.                                           if(eval("\x01") == 800)
  620.                                           {
  621.                                              set("\x01",eval("\x01") + 74);
  622.                                              toggleHighQuality();
  623.                                              break loop0;
  624.                                           }
  625.                                           if(eval("\x01") == 406)
  626.                                           {
  627.                                              set("\x01",eval("\x01") + 394);
  628.                                              if(┬º┬ºpop())
  629.                                              {
  630.                                                 set("\x01",eval("\x01") + 74);
  631.                                              }
  632.                                              continue;
  633.                                           }
  634.                                           if(eval("\x01") == 434)
  635.                                           {
  636.                                              set("\x01",eval("\x01") + 432);
  637.                                              if(┬º┬ºpop())
  638.                                              {
  639.                                                 set("\x01",eval("\x01") - 435);
  640.                                              }
  641.                                              continue;
  642.                                           }
  643.                                           if(eval("\x01") == 930)
  644.                                           {
  645.                                              set("\x01",eval("\x01") - 91);
  646.                                              continue;
  647.                                           }
  648.                                           if(eval("\x01") == 811)
  649.                                           {
  650.                                              set("\x01",eval("\x01") - 30);
  651.                                              continue;
  652.                                           }
  653.                                           if(eval("\x01") == 420)
  654.                                           {
  655.                                              set("\x01",eval("\x01") + 177);
  656.                                              ┬º∩┐╜╚ï∩┐╜\x02'∩┐╜┬º++;
  657.                                              eval("∩┐╜∩┐╜1eiO")[┬º┬ºconstant(2)][┬º┬ºconstant(3)][┬º┬ºconstant(4)] += eval(┬º┬ºconstant(5));
  658.                                              eval("∩┐╜∩┐╜1eiO")[┬º┬ºconstant(2)][┬º┬ºconstant(3)][┬º┬ºconstant(6)] -= 5 + (5 - eval("∩┐╜╚ï∩┐╜\x02\'∩┐╜"));
  659.                                              break loop0;
  660.                                           }
  661.                                           if(eval("\x01") == 708)
  662.                                           {
  663.                                              break loop1;
  664.                                           }
  665.                                           if(eval("\x01") == 628)
  666.                                           {
  667.                                              set("\x01",eval("\x01") + 203);
  668.                                              continue;
  669.                                           }
  670.                                           if(eval("\x01") == 212)
  671.                                           {
  672.                                              set("\x01",eval("\x01") + 718);
  673.                                              break loop0;
  674.                                           }
  675.                                           if(eval("\x01") == 134)
  676.                                           {
  677.                                              set("\x01",eval("\x01") + 1);
  678.                                              stopAllSounds();
  679.                                              ┬º┬ºpush(┬º┬ºpop() or length(┬º┬ºpop()));
  680.                                              break loop0;
  681.                                           }
  682.                                           if(eval("\x01") == 549)
  683.                                           {
  684.                                              set("\x01",eval("\x01") - 415);
  685.                                              if(┬º┬ºpop())
  686.                                              {
  687.                                                 set("\x01",eval("\x01") + 1);
  688.                                              }
  689.                                              continue;
  690.                                           }
  691.                                           if(eval("\x01") == 839)
  692.                                           {
  693.                                              set("\x01",eval("\x01") - 290);
  694.                                              ┬º┬ºpush(true);
  695.                                              continue;
  696.                                           }
  697.                                           if(eval("\x01") == 629)
  698.                                           {
  699.                                              set("\x01",eval("\x01") + 210);
  700.                                              continue;
  701.                                           }
  702.                                           if(eval("\x01") == 259)
  703.                                           {
  704.                                              set("\x01",eval("\x01") + 200);
  705.                                              continue;
  706.                                           }
  707.                                           if(eval("\x01") != 459)
  708.                                           {
  709.                                              if(eval("\x01") == 597)
  710.                                              {
  711.                                                 set("\x01",eval("\x01") - 597);
  712.                                                 break loop0;
  713.                                              }
  714.                                              break loop0;
  715.                                           }
  716.                                           ┬º┬ºpush("\x01");
  717.                                           ┬º┬ºpush("\x01");
  718.                                           set(┬º┬ºpop(),eval(┬º┬ºpop()) - 25);
  719.                                           ┬º┬ºpush(true);
  720.                                        }
  721.                                     }
  722.                                  }
  723.                               }
  724.                            }
  725.                            set("\x01",eval("\x01") - 185);
  726.                            break;
  727.                         }
  728.                         if(eval("\x01") == 923)
  729.                         {
  730.                            set("\x01",eval("\x01") - 923);
  731.                            break;
  732.                         }
  733.                      }
  734.                   }
  735.                   set("\x01",eval("\x01") + 389);
  736.                   ┬º┬ºpush(true);
  737.                   continue;
  738.                }
  739.                set("\x01",eval("\x01") - 541);
  740.                continue;
  741.                set("\x01",eval("\x01") - 45);
  742.             }
  743.             set("\x01",eval("\x01") + 535);
  744.             if(┬º┬ºpop())
  745.             {
  746.                set("\x01",eval("\x01") - 2);
  747.             }
  748.             continue;
  749.          }
  750.          set("\x01",eval("\x01") - 463);
  751.          if(┬º┬ºpop())
  752.          {
  753.             set("\x01",eval("\x01") + 541);
  754.          }
  755.          continue;
  756.       }
  757.       set("\x01",eval("\x01") - 156);
  758.       ┬º┬ºpush(true);
  759.    }
  760. }
  761.